#ifndef PRESENTATION_VIEWMODELS_TASK_VIEW_MODEL_H
#define PRESENTATION_VIEWMODELS_TASK_VIEW_MODEL_H

#include "base_view_model.h"
#include "application/task/task_service.h"
#include "application/task/task_executor.h"
#include <QAbstractListModel>
#include <QString>
#include <QTimer>
#include <memory>

namespace presentation {
namespace viewmodels {

/**
 * @brief 任务列表项（用于QML绑定）
 */
struct TaskListItem {
    QString chainId;
    QString taskName;
    int agvNumber{-1};
    QString agvName;
    QString status;          // "pending", "executing", "completed", "failed", "cancelled"
    QString statusDisplay;   // 状态显示文本
    int currentTaskIndex{0};
    int totalTasks{0};
    int progress{0};         // 0-100
    QString createTime;
    QString errorMessage;

    // 新增字段
    QString currentSubTask;      // 当前子任务名称（Move/Jack/Lift等）
    QString currentSubTaskType;  // 当前子任务类型
    QString targetStation;       // 目标站点
    int currentFloor{-1};        // 当前楼层
    qint64 durationSeconds{0};   // 运行时长（秒）
    bool isPaused{false};        // 是否暂停
    bool isFinished{false};      // 是否完成
};

/**
 * @brief 任务列表模型（用于QML ListView/TableView）
 */
class TaskListModel : public QAbstractListModel {
    Q_OBJECT

public:
    enum TaskRoles {
        ChainIdRole = Qt::UserRole + 1,
        TaskNameRole,
        AgvNumberRole,
        AgvNameRole,
        StatusRole,
        StatusDisplayRole,
        CurrentTaskIndexRole,
        TotalTasksRole,
        ProgressRole,
        CreateTimeRole,
        ErrorMessageRole,
        CurrentSubTaskRole,
        CurrentSubTaskTypeRole,
        TargetStationRole,
        CurrentFloorRole,
        DurationSecondsRole,
        IsPausedRole,
        IsFinishedRole
    };
    Q_ENUM(TaskRoles)

    explicit TaskListModel(QObject* parent = nullptr);
    ~TaskListModel() override = default;

    // QAbstractListModel interface
    int rowCount(const QModelIndex& parent = QModelIndex()) const override;
    QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
    QHash<int, QByteArray> roleNames() const override;

    // 获取指定行的完整任务数据
    Q_INVOKABLE QVariantMap getTaskData(int row) const;

    // 数据更新方法
    void updateData(const std::vector<TaskListItem>& taskList);
    void updateTask(const QString& chainId, const TaskListItem& task);
    void removeTask(const QString& chainId);

private:
    std::vector<TaskListItem> m_taskList;
};

/**
 * @brief 任务管理ViewModel
 * @details MVVM模式：连接TaskService和QML界面
 */
class TaskViewModel : public BaseViewModel {
    Q_OBJECT

    // 属性
    Q_PROPERTY(TaskListModel* taskListModel READ taskListModel CONSTANT)
    Q_PROPERTY(int totalTaskCount READ totalTaskCount NOTIFY totalTaskCountChanged)
    Q_PROPERTY(int activeTaskCount READ activeTaskCount NOTIFY activeTaskCountChanged)
    Q_PROPERTY(int completedTaskCount READ completedTaskCount NOTIFY completedTaskCountChanged)
    Q_PROPERTY(int failedTaskCount READ failedTaskCount NOTIFY failedTaskCountChanged)
    Q_PROPERTY(QStringList availableTemplates READ availableTemplates NOTIFY availableTemplatesChanged)
    Q_PROPERTY(bool callerTriggerEnabled READ callerTriggerEnabled NOTIFY callerTriggerEnabledChanged)
    Q_PROPERTY(bool callerDuplicateCheckEnabled READ callerDuplicateCheckEnabled NOTIFY callerDuplicateCheckEnabledChanged)
    Q_PROPERTY(bool callerMutexCheckEnabled READ callerMutexCheckEnabled NOTIFY callerMutexCheckEnabledChanged)

public:
    explicit TaskViewModel(
        std::shared_ptr<application::task::TaskService> taskService,
        QObject* parent = nullptr
    );

    // 重载构造函数，接受原始指针（由ViewModelFactory使用）
    explicit TaskViewModel(
        application::task::TaskService* taskService,
        QObject* parent = nullptr
    );

    ~TaskViewModel() override = default;

    // 属性访问器
    TaskListModel* taskListModel() const { return m_taskListModel.get(); }
    int totalTaskCount() const { return m_totalTaskCount; }
    int activeTaskCount() const { return m_activeTaskCount; }
    int completedTaskCount() const { return m_completedTaskCount; }
    int failedTaskCount() const { return m_failedTaskCount; }
    QStringList availableTemplates() const { return m_availableTemplates; }
    bool callerTriggerEnabled() const;
    bool callerDuplicateCheckEnabled() const;
    bool callerMutexCheckEnabled() const;

    // ==================== QML调用方法 ====================

    /**
     * @brief 从模板创建任务
     * @param templateName 模板名称
     * @param agvNumber AGV编号（-1表示自动选择）
     * @return 任务链ID或空字符串
     */
    Q_INVOKABLE QString createTaskFromTemplate(const QString& templateName, int agvNumber = -1);

    /**
     * @brief 创建移动任务
     * @param targetStation 目标站点
     * @param floor 楼层
     * @param agvNumber AGV编号
     * @return 任务链ID或空字符串
     */
    Q_INVOKABLE QString createMoveTask(
        const QString& targetStation,
        int floor,
        int agvNumber = -1
    );

    /**
     * @brief 创建充电任务
     * @param agvNumber AGV编号
     * @param chargePoint 充电点
     * @param targetBatteryLevel 目标电量
     * @return 任务链ID或空字符串
     */
    Q_INVOKABLE QString createChargeTask(
        int agvNumber = -1,
        const QString& chargePoint = "",
        int targetBatteryLevel = 100
    );

    /**
     * @brief 创建泊车任务
     * @param agvNumber AGV编号
     * @param parkingStation 泊车站点
     * @return 任务链ID或空字符串
     */
    Q_INVOKABLE QString createParkTask(
        int agvNumber = -1,
        const QString& parkingStation = ""
    );

    /**
     * @brief 暂停任务
     * @param chainId 任务链ID
     * @return 是否成功
     */
    Q_INVOKABLE bool pauseTask(const QString& chainId);

    /**
     * @brief 恢复任务
     * @param chainId 任务链ID
     * @return 是否成功
     */
    Q_INVOKABLE bool resumeTask(const QString& chainId);

    /**
     * @brief 取消任务
     * @param chainId 任务链ID
     * @return 是否成功
     */
    Q_INVOKABLE bool cancelTask(const QString& chainId);

    /**
     * @brief 重新调度指定AGV当前任务
     * @param agvNumber AGV编号
     * @return 是否成功
     */
    Q_INVOKABLE bool rescheduleAgv(int agvNumber);

    /**
     * @brief 重置当前子任务阶段
     */
    Q_INVOKABLE bool resetCurrentSubTask(const QString& chainId);

    /**
     * @brief 刷新任务列表
     */
    Q_INVOKABLE void refreshTasks();

    /**
     * @brief 重新加载任务配置
     * @return 是否成功
     */
    Q_INVOKABLE bool reloadTaskConfig();

    /**
     * @brief 获取任务详情
     * @param chainId 任务链ID
     * @return 任务详情（QVariantMap）
     */
    Q_INVOKABLE QVariantMap getTaskDetails(const QString& chainId);

    /**
     * @brief 设置呼叫器触发任务是否启用（维护模式开关）
     * @param enabled true=启用呼叫器触发，false=禁用（维护模式）
     */
    Q_INVOKABLE void setCallerTriggerEnabled(bool enabled);

    /**
     * @brief 设置呼叫器连发检查是否启用
     * @param enabled true=启用连发检查，false=禁用
     */
    Q_INVOKABLE void setCallerDuplicateCheckEnabled(bool enabled);

    /**
     * @brief 设置呼叫器对发检查是否启用
     * @param enabled true=启用对发检查，false=禁用
     */
    Q_INVOKABLE void setCallerMutexCheckEnabled(bool enabled);

signals:
    // 属性变化信号
    void totalTaskCountChanged();
    void activeTaskCountChanged();
    void completedTaskCountChanged();
    void failedTaskCountChanged();
    void availableTemplatesChanged();
    void callerTriggerEnabledChanged();
    void callerDuplicateCheckEnabledChanged();
    void callerMutexCheckEnabledChanged();

    // 业务信号
    void taskCreated(const QString& chainId);
    void taskCompleted(const QString& chainId, bool success);
    void taskProgressUpdated(const QString& chainId, int current, int total);
    void taskStatusUpdated(const QString& chainId, const QString& status);
    void errorOccurred(const QString& message);

private slots:
    // 处理 TaskExecutor 信号
    void onTaskChainCompleted(const QString& chainId, bool success);
    void onTaskChainProgressUpdated(const QString& chainId, int current, int total);
    void onTaskChainStatusUpdated(const QString& chainId, const QString& status);
    void onTaskChainAdded(const QString& chainId, int agvNumber, const QString& taskName);
    void onTaskChainRemoved(const QString& chainId);

private:
    std::shared_ptr<application::task::TaskService> m_taskService;
    std::unique_ptr<TaskListModel> m_taskListModel;

    // 统计数据
    int m_totalTaskCount{0};
    int m_activeTaskCount{0};
    int m_completedTaskCount{0};
    int m_failedTaskCount{0};

    // 可用模板列表
    QStringList m_availableTemplates;

    // 任务数据缓存（chainId -> TaskListItem）
    QMap<QString, TaskListItem> m_taskCache;

    // 辅助方法
    void updateTaskList();
    void updateStatistics();
    void loadAvailableTemplates();
    TaskListItem createTaskListItem(const application::task::TaskChainState* state);
    QString formatTaskStatus(const application::task::TaskChainState* state);
    QString getAgvName(int agvNumber);
};

} // namespace viewmodels
} // namespace presentation

#endif // PRESENTATION_VIEWMODELS_TASK_VIEW_MODEL_H
